using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("Box")]
	public class Box : MonoBehaviour
	{
		[Attribute38("Box.BoxSpecialEvent")]
		public class BoxSpecialEvent : MonoClass
		{
			public SpecialEventType EventType => method_2<SpecialEventType>("EventType");

			public string Prefab => method_4("Prefab");

			public string PrefabPhoneOverride => method_4("PrefabPhoneOverride");

			public string BoxTexture => method_4("BoxTexture");

			public string BoxTexturePhone => method_4("BoxTexturePhone");

			public string TableTexture => method_4("TableTexture");

			public bool showToReturningPlayers => method_2<bool>("showToReturningPlayers");

			public bool showToNewPlayers => method_2<bool>("showToNewPlayers");

			public BoxSpecialEvent(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BoxSpecialEvent(IntPtr address)
				: this(address, "BoxSpecialEvent")
			{
			}
		}

		public enum State
		{
			INVALID,
			STARTUP,
			PRESS_START,
			LOADING,
			LOADING_HUB,
			HUB,
			HUB_WITH_DRAWER,
			OPEN,
			CLOSED,
			ERROR,
			SET_ROTATION_LOADING,
			SET_ROTATION,
			SET_ROTATION_OPEN
		}

		public enum ButtonType
		{
			START,
			TOURNAMENT,
			ADVENTURE,
			FORGE,
			OPEN_PACKS,
			COLLECTION,
			TAVERN_BRAWL,
			SET_ROTATION,
			QUEST_LOG,
			STORE
		}

		[Attribute38("Box.BoxStateConfig")]
		public class BoxStateConfig : MonoClass
		{
			public BoxStateConfig(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BoxStateConfig(IntPtr address)
				: this(address, "BoxStateConfig")
			{
			}
		}

		public enum DataState
		{
			NONE,
			REQUEST_SENT,
			RECEIVED,
			UNLOADING
		}

		public GameObject m_rootObject => method_3<GameObject>("m_rootObject");

		public BoxStateInfoList m_StateInfoList => method_3<BoxStateInfoList>("m_StateInfoList");

		public BoxLogo m_Logo => method_3<BoxLogo>("m_Logo");

		public BoxStartButton m_StartButton => method_3<BoxStartButton>("m_StartButton");

		public BoxDoor m_LeftDoor => method_3<BoxDoor>("m_LeftDoor");

		public BoxDoor m_RightDoor => method_3<BoxDoor>("m_RightDoor");

		public BoxDisk m_Disk => method_3<BoxDisk>("m_Disk");

		public GameObject m_DiskCenter => method_3<GameObject>("m_DiskCenter");

		public BoxSpinner m_TopSpinner => method_3<BoxSpinner>("m_TopSpinner");

		public BoxSpinner m_BottomSpinner => method_3<BoxSpinner>("m_BottomSpinner");

		public BoxDrawer m_Drawer => method_3<BoxDrawer>("m_Drawer");

		public BoxCamera m_Camera => method_3<BoxCamera>("m_Camera");

		public Camera m_NoFxCamera => method_3<Camera>("m_NoFxCamera");

		public BoxLightMgr m_LightMgr => method_3<BoxLightMgr>("m_LightMgr");

		public BoxEventMgr m_EventMgr => method_3<BoxEventMgr>("m_EventMgr");

		public BoxMenuButton m_PlayButton => method_3<BoxMenuButton>("m_PlayButton");

		public BoxMenuButton m_SoloAdventuresButton => method_3<BoxMenuButton>("m_SoloAdventuresButton");

		public BoxMenuButton m_ForgeButton => method_3<BoxMenuButton>("m_ForgeButton");

		public TavernBrawlMenuButton m_TavernBrawlButton => method_3<TavernBrawlMenuButton>("m_TavernBrawlButton");

		public GameObject m_EmptyFourthButton => method_3<GameObject>("m_EmptyFourthButton");

		public GameObject m_TavernBrawlButtonVisual => method_3<GameObject>("m_TavernBrawlButtonVisual");

		public GameObject m_TavernBrawlButtonActivateFX => method_3<GameObject>("m_TavernBrawlButtonActivateFX");

		public GameObject m_TavernBrawlButtonDeactivateFX => method_3<GameObject>("m_TavernBrawlButtonDeactivateFX");

		public string m_tavernBrawlActivateSound => method_4("m_tavernBrawlActivateSound");

		public string m_tavernBrawlDeactivateSound => method_4("m_tavernBrawlDeactivateSound");

		public string m_tavernBrawlPopupSound => method_4("m_tavernBrawlPopupSound");

		public string m_tavernBrawlPopdownSound => method_4("m_tavernBrawlPopdownSound");

		public List<string> m_tavernBrawlEnterCrowdSounds => method_3<Class272>("m_tavernBrawlEnterCrowdSounds")?.method_25();

		public PackOpeningButton m_OpenPacksButton => method_3<PackOpeningButton>("m_OpenPacksButton");

		public BoxMenuButton m_CollectionButton => method_3<BoxMenuButton>("m_CollectionButton");

		public StoreButton m_StoreButton => method_3<StoreButton>("m_StoreButton");

		public QuestLogButton m_QuestLogButton => method_3<QuestLogButton>("m_QuestLogButton");

		public Color m_EnabledMaterial => method_2<Color>("m_EnabledMaterial");

		public Color m_DisabledMaterial => method_2<Color>("m_DisabledMaterial");

		public Color m_EnabledDrawerMaterial => method_2<Color>("m_EnabledDrawerMaterial");

		public Color m_DisabledDrawerMaterial => method_2<Color>("m_DisabledDrawerMaterial");

		public GameObject m_OuterFrame => method_3<GameObject>("m_OuterFrame");

		public RibbonButtonsUI m_ribbonButtons => method_3<RibbonButtonsUI>("m_ribbonButtons");

		public GameObject m_letterboxingContainer => method_3<GameObject>("m_letterboxingContainer");

		public GameObject m_tableTop => method_3<GameObject>("m_tableTop");

		public GameObject m_firesideGatheringTavernBrawlButtonFX => method_3<GameObject>("m_firesideGatheringTavernBrawlButtonFX");

		public GameObject m_firesideGatheringTavernBrawlButtonFlag => method_3<GameObject>("m_firesideGatheringTavernBrawlButtonFlag");

		public List<BoxSpecialEvent> m_specialEvents => method_3<Class271<BoxSpecialEvent>>("m_specialEvents")?.method_25();

		public Spell m_activeSpecialEvent => method_3<Spell>("m_activeSpecialEvent");

		public bool m_isSpecialEventActive => method_2<bool>("m_isSpecialEventActive");

		public List<BoxStateConfig> m_stateConfigs => method_3<Class251<BoxStateConfig>>("m_stateConfigs")?.method_25();

		public State m_state => method_2<State>("m_state");

		public int m_pendingEffects => method_2<int>("m_pendingEffects");

		public bool m_transitioningToSceneMode => method_2<bool>("m_transitioningToSceneMode");

		public bool m_waitingForNetData => method_2<bool>("m_waitingForNetData");

		public GameLayer m_originalLeftDoorLayer => method_2<GameLayer>("m_originalLeftDoorLayer");

		public GameLayer m_originalRightDoorLayer => method_2<GameLayer>("m_originalRightDoorLayer");

		public GameLayer m_originalDrawerLayer => method_2<GameLayer>("m_originalDrawerLayer");

		public bool m_waitingForSceneLoad => method_2<bool>("m_waitingForSceneLoad");

		public bool m_showRibbonButtons => method_2<bool>("m_showRibbonButtons");

		public bool m_showFSGBanner => method_2<bool>("m_showFSGBanner");

		public static string SHOW_LOG_COROUTINE => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "Box", "SHOW_LOG_COROUTINE");

		public bool m_questLogLoading => method_2<bool>("m_questLogLoading");

		public DataState m_questLogNetCacheDataState => method_2<DataState>("m_questLogNetCacheDataState");

		public QuestLog m_questLog => method_3<QuestLog>("m_questLog");

		public GameObject m_tempInputBlocker => method_3<GameObject>("m_tempInputBlocker");

		public GameObject m_setRotationDisk => method_3<GameObject>("m_setRotationDisk");

		public BoxMenuButton m_setRotationButton => method_3<BoxMenuButton>("m_setRotationButton");

		public bool IsTavernBrawlButtonDeactivated => method_11<bool>("get_IsTavernBrawlButtonDeactivated", Array.Empty<object>());

		public Box(IntPtr address, string className)
			: base(address, className)
		{
		}

		public Box(IntPtr address)
			: this(address, "Box")
		{
		}

		public static Box Get()
		{
			return MonoClass.smethod_15<Box>(TritonHs.MainAssemblyPath, "", "Box", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public Camera GetCamera()
		{
			return method_14<Camera>("GetCamera", Array.Empty<object>());
		}

		public BoxCamera GetBoxCamera()
		{
			return method_14<BoxCamera>("GetBoxCamera", Array.Empty<object>());
		}

		public Camera GetNoFxCamera()
		{
			return method_14<Camera>("GetNoFxCamera", Array.Empty<object>());
		}

		public State GetState()
		{
			return method_11<State>("GetState", Array.Empty<object>());
		}

		public bool ChangeState(State state)
		{
			return method_11<bool>("ChangeState", new object[1] { state });
		}

		public void UpdateState()
		{
			method_8("UpdateState");
		}

		public BoxLightMgr GetLightMgr()
		{
			return method_14<BoxLightMgr>("GetLightMgr", Array.Empty<object>());
		}

		public BoxLightStateType GetLightState()
		{
			return method_11<BoxLightStateType>("GetLightState", Array.Empty<object>());
		}

		public void ChangeLightState(BoxLightStateType stateType)
		{
			method_8("ChangeLightState", stateType);
		}

		public void SetLightState(BoxLightStateType stateType)
		{
			method_8("SetLightState", stateType);
		}

		public BoxEventMgr GetEventMgr()
		{
			return method_14<BoxEventMgr>("GetEventMgr", Array.Empty<object>());
		}

		public Spell GetEventSpell(BoxEventType eventType)
		{
			return method_14<Spell>("GetEventSpell", new object[1] { eventType });
		}

		public bool HasPendingEffects()
		{
			return method_11<bool>("HasPendingEffects", Array.Empty<object>());
		}

		public bool IsBusy()
		{
			return method_11<bool>("IsBusy", Array.Empty<object>());
		}

		public bool IsTransitioningToSceneMode()
		{
			return method_11<bool>("IsTransitioningToSceneMode", Array.Empty<object>());
		}

		public void OnAnimStarted()
		{
			method_8("OnAnimStarted");
		}

		public void OnAnimFinished()
		{
			method_8("OnAnimFinished");
		}

		public void OnLoggedIn()
		{
			method_8("OnLoggedIn");
		}

		public void SetToIgnoreFullScreenEffects(bool ignoreEffects)
		{
			method_8("SetToIgnoreFullScreenEffects", ignoreEffects);
		}

		public void PlayTavernBrawlCrowdSFX()
		{
			method_8("PlayTavernBrawlCrowdSFX");
		}

		public void InitializeStateConfigs()
		{
			method_8("InitializeStateConfigs");
		}

		public void InitializeState()
		{
			method_8("InitializeState");
		}

		public void OnTutorialSceneDestroyed(object userData)
		{
			method_8("OnTutorialSceneDestroyed", userData);
		}

		public void OnTutorialPlaySpellStateFinished(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnTutorialPlaySpellStateFinished", spell, prevStateType, userData);
		}

		public void ShutdownState()
		{
			method_8("ShutdownState");
		}

		public void QueueStateChange(State state)
		{
			method_8("QueueStateChange", state);
		}

		public void ChangeStateQueued()
		{
			method_8("ChangeStateQueued");
		}

		public void ChangeStateNow(State state)
		{
			method_8("ChangeStateNow", state);
		}

		public void ChangeStateToReflectSceneMode(SceneMgr.Mode mode, bool isSceneActuallyLoaded)
		{
			method_8("ChangeStateToReflectSceneMode", mode, isSceneActuallyLoaded);
		}

		public State TranslateSceneModeToBoxState(SceneMgr.Mode mode)
		{
			return method_11<State>("TranslateSceneModeToBoxState", new object[1] { mode });
		}

		public BoxLightStateType TranslateSceneModeToLightState(SceneMgr.Mode mode)
		{
			return method_11<BoxLightStateType>("TranslateSceneModeToLightState", new object[1] { mode });
		}

		public void OnScenePreUnload(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnScenePreUnload", prevMode, prevScene, userData);
		}

		public bool ShouldUseLoadingHubState(SceneMgr.Mode mode, SceneMgr.Mode prevMode)
		{
			return method_11<bool>("ShouldUseLoadingHubState", new object[2] { mode, prevMode });
		}

		public void OnSceneLoaded(SceneMgr.Mode mode, PegasusScene scene, object userData)
		{
			method_8("OnSceneLoaded", mode, scene, userData);
		}

		public void ChangeState_Startup()
		{
			method_8("ChangeState_Startup");
		}

		public void ChangeState_PressStart()
		{
			method_8("ChangeState_PressStart");
		}

		public void ChangeState_SetRotationLoading()
		{
			method_8("ChangeState_SetRotationLoading");
		}

		public void ChangeState_SetRotation()
		{
			method_8("ChangeState_SetRotation");
		}

		public void ChangeState_SetRotationOpen()
		{
			method_8("ChangeState_SetRotationOpen");
		}

		public void ChangeState_LoadingHub()
		{
			method_8("ChangeState_LoadingHub");
		}

		public void ChangeState_Loading()
		{
			method_8("ChangeState_Loading");
		}

		public void ChangeState_Hub()
		{
			method_8("ChangeState_Hub");
		}

		public void ChangeState_HubWithDrawer()
		{
			method_8("ChangeState_HubWithDrawer");
		}

		public void ChangeState_Open()
		{
			method_8("ChangeState_Open");
		}

		public void ChangeState_Closed()
		{
			method_8("ChangeState_Closed");
		}

		public void ChangeState_Error()
		{
			method_8("ChangeState_Error");
		}

		public void UpdateState_Startup()
		{
			method_8("UpdateState_Startup");
		}

		public void UpdateState_PressStart()
		{
			method_8("UpdateState_PressStart");
		}

		public void UpdateState_SetRotationLoading()
		{
			method_8("UpdateState_SetRotationLoading");
		}

		public void UpdateState_SetRotation()
		{
			method_8("UpdateState_SetRotation");
		}

		public void UpdateState_SetRotationOpen()
		{
			method_8("UpdateState_SetRotationOpen");
		}

		public void UpdateState_LoadingHub()
		{
			method_8("UpdateState_LoadingHub");
		}

		public void UpdateState_Loading()
		{
			method_8("UpdateState_Loading");
		}

		public void UpdateState_Hub()
		{
			method_8("UpdateState_Hub");
		}

		public void UpdateState_HubWithDrawer()
		{
			method_8("UpdateState_HubWithDrawer");
		}

		public void UpdateState_Open()
		{
			method_8("UpdateState_Open");
		}

		public void UpdateState_Closed()
		{
			method_8("UpdateState_Closed");
		}

		public void UpdateState_Error()
		{
			method_8("UpdateState_Error");
		}

		public void ChangeStateUsingConfig()
		{
			method_8("ChangeStateUsingConfig");
		}

		public void ToggleRibbonUI(bool show)
		{
			method_8("ToggleRibbonUI", show);
		}

		public void UpdateStateUsingConfig()
		{
			method_8("UpdateStateUsingConfig");
		}

		public void FullScreenBlack_ChangeState(bool enable)
		{
			method_8("FullScreenBlack_ChangeState", enable);
		}

		public void FullScreenBlack_UpdateState(bool enable)
		{
			method_8("FullScreenBlack_UpdateState", enable);
		}

		public void FireTransitionFinishedEvent()
		{
			method_8("FireTransitionFinishedEvent");
		}

		public void InitializeUI()
		{
			method_8("InitializeUI");
		}

		public void UpdateUI(bool isInitialization)
		{
			method_8("UpdateUI", isInitialization);
		}

		public void TavernBrawl_UpdateUI()
		{
			method_8("TavernBrawl_UpdateUI");
		}

		public void UpdateUIState(bool isInitialization)
		{
			method_8("UpdateUIState", isInitialization);
		}

		public void OnFSGSignShown()
		{
			method_8("OnFSGSignShown");
		}

		public void DoTavernBrawlButtonInitialization()
		{
			method_8("DoTavernBrawlButtonInitialization");
		}

		public void PlayTavernBrawlButtonActivation(bool activate, bool isInitialization)
		{
			method_8("PlayTavernBrawlButtonActivation", activate, isInitialization);
		}

		public bool UpdateTavernBrawlButtonState(bool highlightAllowed)
		{
			return method_11<bool>("UpdateTavernBrawlButtonState", new object[1] { highlightAllowed });
		}

		public void ActivateFiresideBrawlButton(bool isCheckedIn)
		{
			method_8("ActivateFiresideBrawlButton", isCheckedIn);
		}

		public void UpdateUIEvents()
		{
			method_8("UpdateUIEvents");
		}

		public bool CanEnableUIEvents()
		{
			return method_11<bool>("CanEnableUIEvents", Array.Empty<object>());
		}

		public void RegisterButtonEvents(PegUIElement button)
		{
			method_8("RegisterButtonEvents", button);
		}

		public void ToggleButtonTextureState(bool enabled, BoxMenuButton button)
		{
			method_8("ToggleButtonTextureState", enabled, button);
		}

		public void ToggleDrawerButtonState(bool enabled, BoxMenuButton button)
		{
			method_8("ToggleDrawerButtonState", enabled, button);
		}

		public void HighlightButton(BoxMenuButton button, bool highlightOn)
		{
			method_8("HighlightButton", button, highlightOn);
		}

		public bool IsButtonHighlighted(BoxMenuButton button)
		{
			return method_11<bool>("IsButtonHighlighted", new object[1] { button });
		}

		public void SetPackCount(int n)
		{
			method_8("SetPackCount", n);
		}

		public void EnableButton(PegUIElement button)
		{
			method_8("EnableButton", button);
		}

		public void DisableButton(PegUIElement button)
		{
			method_8("DisableButton", button);
		}

		public void OnButtonPressed(UIEvent e)
		{
			method_8("OnButtonPressed", e);
		}

		public void FireButtonPressEvent(ButtonType buttonType)
		{
			method_8("FireButtonPressEvent", buttonType);
		}

		public void ClearQueuedButtonFireEvent()
		{
			method_8("ClearQueuedButtonFireEvent");
		}

		public void OnStartButtonPressed(UIEvent e)
		{
			method_8("OnStartButtonPressed", e);
		}

		public void OnTournamentButtonPressed(UIEvent e)
		{
			method_8("OnTournamentButtonPressed", e);
		}

		public void OnSetRotationButtonPressed(UIEvent e)
		{
			method_8("OnSetRotationButtonPressed", e);
		}

		public void OnSoloAdventuresButtonPressed(UIEvent e)
		{
			method_8("OnSoloAdventuresButtonPressed", e);
		}

		public void OnForgeButtonPressed(UIEvent e)
		{
			method_8("OnForgeButtonPressed", e);
		}

		public void OnTavernBrawlButtonPressed(UIEvent e)
		{
			method_8("OnTavernBrawlButtonPressed", e);
		}

		public void OnOpenPacksButtonPressed(UIEvent e)
		{
			method_8("OnOpenPacksButtonPressed", e);
		}

		public void OnCollectionButtonPressed(UIEvent e)
		{
			method_8("OnCollectionButtonPressed", e);
		}

		public void OnQuestButtonPressed(UIEvent e)
		{
			method_8("OnQuestButtonPressed", e);
		}

		public void OnButtonMouseOver(UIEvent e)
		{
			method_8("OnButtonMouseOver", e);
		}

		public void OnButtonMouseOut(UIEvent e)
		{
			method_8("OnButtonMouseOut", e);
		}

		public void InitializeNet()
		{
			method_8("InitializeNet");
		}

		public void ShutdownNet()
		{
			method_8("ShutdownNet");
		}

		public void OnNetCacheReady()
		{
			method_8("OnNetCacheReady");
		}

		public int ComputeBoosterCount()
		{
			return method_11<int>("ComputeBoosterCount", Array.Empty<object>());
		}

		public void UnloadQuestLog()
		{
			method_8("UnloadQuestLog");
		}

		public void DestroyQuestLog()
		{
			method_8("DestroyQuestLog");
		}

		public void OnQuestLogLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnQuestLogLoaded", assetRef, go, callbackData);
		}

		public void OnQuestLogNetCacheReady()
		{
			method_8("OnQuestLogNetCacheReady");
		}

		public bool ShouldRequestData(DataState state)
		{
			return method_11<bool>("ShouldRequestData", new object[1] { state });
		}

		public void OnStoreButtonReleased(UIEvent e)
		{
			method_8("OnStoreButtonReleased", e);
		}

		public void OnStoreShown(object userData)
		{
			method_8("OnStoreShown", userData);
		}

		public void SetRotation_ShowRotationDisk()
		{
			method_8("SetRotation_ShowRotationDisk");
		}

		public void SetRotation_ShowNerfedCards_DialogHidden(DialogBase dialog, object userData)
		{
			method_8("SetRotation_ShowNerfedCards_DialogHidden", dialog, userData);
		}

		public void SetRotation_FinishShowingRewards()
		{
			method_8("SetRotation_FinishShowingRewards");
		}

		public void BoxSpecialEvents()
		{
			method_8("BoxSpecialEvents");
		}

		public void LoadBoxSpecialEvent()
		{
			method_8("LoadBoxSpecialEvent");
		}

		public void LoadSpecialEventTableTexture(string texturePath)
		{
			method_8("LoadSpecialEventTableTexture", texturePath);
		}

		public void LoadSpecialEventBoxTexture(string texturePath)
		{
			method_8("LoadSpecialEventBoxTexture", texturePath);
		}

		public void LoadSpecialEventSpell(BoxSpecialEvent boxSpecialEvent)
		{
			method_8("LoadSpecialEventSpell", boxSpecialEvent);
		}

		public void InitializeComponents()
		{
			method_8("InitializeComponents");
		}

		public void OnBoxTopPhoneTextureLoaded(AssetReference assetRef, object obj, object callbackData)
		{
			method_8("OnBoxTopPhoneTextureLoaded", assetRef, obj, callbackData);
		}
	}
}
